{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 并发下载"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 一.queue的实现"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "from queue import Queue\n",
    "\n",
    "queue_object=Queue()\n",
    "\n",
    "for i in range(4):\n",
    "    queue_object.put(i)\n",
    "    \n",
    "while not queue_object.empty():\n",
    "    print(queue_object.get())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n",
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "from queue import LifoQueue\n",
    "\n",
    "lifo_queue=LifoQueue()\n",
    "\n",
    "for i in range(4):\n",
    "    lifo_queue.put(i)\n",
    "    \n",
    "while not lifo_queue.empty():\n",
    "    print(lifo_queue.get())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始工作： 重要工作\n",
      "开始工作： 中级别工作\n",
      "开始工作： 低级别工作\n"
     ]
    }
   ],
   "source": [
    "from queue import PriorityQueue\n",
    "\n",
    "class Job(object):\n",
    "    def __init__(self,level,description):\n",
    "        self.level=level\n",
    "        self.description=description\n",
    "        return\n",
    "    \n",
    "    def __lt__(self,other):\n",
    "        return self.level<other.level\n",
    "    \n",
    "priority_queue=PriorityQueue()\n",
    "\n",
    "priority_queue.put(Job(5,\"中级别工作\"))\n",
    "priority_queue.put(Job(10,\"低级别工作\"))\n",
    "priority_queue.put(Job(1,\"重要工作\"))\n",
    "\n",
    "while not priority_queue.empty():\n",
    "    next_job=priority_queue.get()\n",
    "    print(\"开始工作：\",next_job.description)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 二.三种技术采集和解析数据对比"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.单线程实现"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>步骤：构建网址--->访问网页并获取源代码--->解析源代码--->转成JSON格式--->存储在本地文件</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from lxml import etree\n",
    "import requests\n",
    "import json\n",
    "\n",
    "# 访问网页的请求头\n",
    "headers={\n",
    "    \"User-Agent\":\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.108 Safari/537.36\",\n",
    "    \"Accept-Language\":\"zh-CN,zh;q=0.8\"\n",
    "}\n",
    "\n",
    "# 存储解析后数据的本地文件\n",
    "local_file=open(\"duanzi.json\",\"a\")\n",
    "\n",
    "# 解析 html字符串,获取需要信息\n",
    "def parse_html(html):\n",
    "    text=etree.HTML(html)\n",
    "    \n",
    "    # 返回所有段子的结点位置\n",
    "    # contains模糊查询,第一个参数是要匹配的标签,第二个参数是标签名的部分内容\n",
    "    node_list=text.xpath('//li[contains(@id,\"qiushi_tag\")]')\n",
    "    \n",
    "    for node in node_list:\n",
    "        # 获取用户名\n",
    "        username=node.xpath('.//span[@class=\"recmd-name\"]/text()')\n",
    "    \n",
    "        #图片链接\n",
    "        image=node.xpath('.//img/@src')[0]\n",
    "    \n",
    "        # 段子内容\n",
    "        content=node.xpath('.//a[@class=\"recmd-content\"]')[0].text\n",
    "    \n",
    "        #点赞\n",
    "        like=node.xpath('.//div[@class=\"recmd-num\"]/span')[0].text\n",
    "    \n",
    "        # 评论\n",
    "        try:\n",
    "            comments=node.xpath('.//div[@class=\"recmd-num\"]/span')[3].text\n",
    "        except IndexError:\n",
    "            comments=0\n",
    "    \n",
    "        items={\n",
    "            \"username\":username,\n",
    "            \"image\":image,\n",
    "            \"content\":content,\n",
    "            \"like\":like,\n",
    "            \"comments\":comments\n",
    "        }\n",
    "    \n",
    "        local_file.write(json.dumps(items,ensure_ascii=False)+\"\\n\")\n",
    "        \n",
    "def main():\n",
    "    # 获取1-10页的网页源代码解析\n",
    "    for page in range(1,11):\n",
    "        url=\"https://www.qiushibaike.com/8hr/page/\"+str(page)+\"/\"\n",
    "        # 爬取网页源代码\n",
    "        html=requests.get(url,headers=headers).text\n",
    "        \n",
    "        parse_html(html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.多线程实现"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从单线程爬虫的流程可以看出,全部过程只是用了一个线程,先爬取一个网页,对网页内容进行解析,然后存储,完成整套操作后再开始爬取下一个网页,每个网页依次进行,效率非常慢"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "爬虫的流程简要步骤如下：\n",
    "1. 使用一个队列pageQueue保存要访问的网页页码\n",
    "2. 同时启动多个采集线程,每个线程都从网页页码队列pageQueue中取出一个要访问的页码,构建网址,访问网址并爬取数据.操作完一个网页后再从网页页码队列中取出下一个页码,依次进行,直到所有的页码都已访问完毕.所有的采集线程保存在列表threadCrawls中\n",
    "3. 使用一个队列dataQueue来保存所有的网页源代码,每个线程获取到的数据都放入该队列中\n",
    "4. 同时启动多个解析线程,每个线程都从网页源代码队列dataQueue中取出一个网页源代码,并进行解析,获取想要的数据,并转化为JSON格式.解析完成后再取出下一个网页源代码,依次进行,直到所有的源代码都已被取出.将所有的解析线程存储在列表threadParses中\n",
    "5. 将解析得到的JSON数据存储在本地文件duanzi.json中"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 26,
     "metadata": {
      "image/png": {
       "width": 500
      }
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "Image(filename=\"./data/thread.png\",width=500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>创建一个ThreadCrawl类,继承自threading.Thread类,用于采集网页信息</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/usr/bin/env python3\n",
    "# -*- coding:utf-8 -*-\n",
    "# Author LQ6H\n",
    "\n",
    "import requests\n",
    "import threading\n",
    "from lxml import etree\n",
    "import json\n",
    "from queue import Queue\n",
    "\n",
    "\n",
    "# 采集网页页码队列是否为空的信号\n",
    "CRAWL_EXIT=False\n",
    "\n",
    "class ThreadCrawl(threading.Thread):\n",
    "    def __init__(self,threadName,pageQueue,dataQueue):\n",
    "        threading.Thread.__init__(self)\n",
    "        # 线程名\n",
    "        self.threadName=threadName\n",
    "        # 页码队列\n",
    "        self.pageQueue=pageQueue\n",
    "        # 数据队列\n",
    "        self.dataQueue=dataQueue\n",
    "\n",
    "        self.headers=\"{'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.108 Safari/537.36'}\"\n",
    "\n",
    "    def run(self):\n",
    "        print(\"启动：\"+self.threadName)\n",
    "\n",
    "        while not CRAWL_EXIT:\n",
    "            try:\n",
    "                # 从dataQueue中取出1一个页码数字,先进先出\n",
    "                # 可选参数block,默认值是True\n",
    "                # 如果队列为空,block为True,会进入阻塞状态,直到队列有新的数据\n",
    "                # 如果队列为空,block为False,会弹出一个Queue.empty()异常\n",
    "                page=self.pageQueue.get(False)\n",
    "                # 构建网页的URL地址\n",
    "                url=\"https://www.qiushibaike.com/8hr/page/\"+str(page)+\"/\"\n",
    "                content=requests.get(url,headers=self.headers).text\n",
    "\n",
    "                # 将爬取到的网页源代码放入dataQueue队列中\n",
    "                self.dataQueue.put(content)\n",
    "            except:\n",
    "                pass\n",
    "\n",
    "        print(\"结束：\"+self.threadName)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先定义一个全局变量CRAWL_EXIT,用于标识pageQueue队列是否为空.当pageQueue不玩空时,线程继续爬取下一个页码;当pageQueue为空时,表明所有的网页都已被爬取完毕,线程就可以退出"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "队列pageQueue是线程安全的,使用队列来调度线程,保证了每个线程采集的网页地址不重复"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "创建一个ThreadParse类,继承自threading.Thread,用于解析网页信息"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "PARSE_EXIT=False\n",
    "class ThreadParse(threading.Thread):\n",
    "    def __init__(self,threadName,dataQueue,localFile,lock):\n",
    "        super(ThreadParse,self).__init__()\n",
    "        # 线程名\n",
    "        self.threadName=threadName\n",
    "        # 数据队列\n",
    "        self.dataQueue=dataQueue\n",
    "        # 保存解析后数据的文件名\n",
    "        self.localFile=localFile\n",
    "        # 互斥锁\n",
    "        self.lock=lock\n",
    "\n",
    "    def run(self):\n",
    "        print(\"启动：\"+self.threadName)\n",
    "        while not PARSE_EXIT:\n",
    "            try:\n",
    "                html=self.dataQueue.get(False)\n",
    "                self.parse(html)\n",
    "\n",
    "            except:\n",
    "                pass\n",
    "\n",
    "        print(\"结束：\"+self.threadName)\n",
    "\n",
    "\n",
    "    def parse(self,html):\n",
    "        text = etree.HTML(html)\n",
    "        node_list = text.xpath('//li[contains(@id,\"qiushi_tag\")]')\n",
    "\n",
    "        for node in node_list:\n",
    "            try:\n",
    "\n",
    "                # 获取用户名\n",
    "                username = node.xpath('.//span[@class=\"recmd-name\"]/text()')\n",
    "\n",
    "                # 图片链接\n",
    "                image = node.xpath('.//img/@src')[0]\n",
    "\n",
    "                # 段子内容\n",
    "                content = node.xpath('.//a[@class=\"recmd-content\"]')[0].text\n",
    "\n",
    "                # 点赞\n",
    "                like = node.xpath('.//div[@class=\"recmd-num\"]/span')[0].text\n",
    "\n",
    "                # 评论\n",
    "                try:\n",
    "                    comments = node.xpath('.//div[@class=\"recmd-num\"]/span')[3].text\n",
    "                except IndexError:\n",
    "                    comments = 0\n",
    "\n",
    "                items = {\n",
    "                    \"username\": username,\n",
    "                    \"image\": image,\n",
    "                    \"content\": content,\n",
    "                    \"like\": like,\n",
    "                    \"comments\": comments\n",
    "                }\n",
    "\n",
    "\n",
    "                # with后面有两个必须执行的操作：__enter__和__exit__,打开和关闭\n",
    "                # 不管里面的操作如何,都会直接打开和关闭功能\n",
    "                # 打开锁,向文件添加内容,释放锁\n",
    "\n",
    "                with self.lock:\n",
    "                    # 写入解析后的数据\n",
    "                    self.localFile.write(json.dumps(items,ensure_ascii=False)+\"\\n\")\n",
    "            except:\n",
    "                pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在多线程开发中,为了维护资源的完整性,在访问共享资源时使用共享锁lock.线程获得了锁之后,才可以访问文件localFile,并往里写入数据,写入完毕后,将锁释放,其他线程就可以访问这个文件.同一时刻,只允许一个协程访问该文件"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "def main():\n",
    "    # 页码队列,存储10个页码,先进先出\n",
    "    pageQueue=Queue(10)\n",
    "    for i in range(1,11):\n",
    "        pageQueue.put(i)\n",
    "\n",
    "    # 采集结果(网页的HTML源代码)的数据队列,参数为空表示不限制\n",
    "    dataQueue=Queue()\n",
    "    # 以追加的方式打开本地文件\n",
    "    localFile=open(\"duanzi.json\",\"wb+\")\n",
    "    # 互斥锁\n",
    "    lock=threading.Lock()\n",
    "\n",
    "    # 3个采集线程的名字\n",
    "    crawlList=[\"采集线程1号\",\"采集线程2号\",\"采集线程3号\"]\n",
    "    # 创建,启动和存储3个采集线程\n",
    "    threadCrawls=[]\n",
    "\n",
    "    for threadName in crawlList:\n",
    "        thread=ThreadCrawl(threadName,pageQueue,dataQueue)\n",
    "        thread.start()\n",
    "        threadCrawls.append(thread)\n",
    "\n",
    "    # 3个解析线程的名字\n",
    "    parseList=[\"解析线程1号\",\"解析线程2号\",\"解析线程3号\"]\n",
    "    # 创建,启动和存储3个解析线程\n",
    "    threadParses=[]\n",
    "    for threadName in parseList:\n",
    "        thread=ThreadParse(threadName,dataQueue,localFile,lock)\n",
    "        thread.start()\n",
    "        threadParses.append(thread)\n",
    "\n",
    "    while not pageQueue.empty():\n",
    "        pass\n",
    "\n",
    "    # 如果pageQueue为空,采集线程退出循环\n",
    "    global CRAWL_EXIT\n",
    "    CRAWL_EXIT=True\n",
    "\n",
    "    print(\"pageQueue为空\\n\")\n",
    "\n",
    "    for thread in threadCrawls:\n",
    "        # 阻塞子线程\n",
    "        thread.join()\n",
    "\n",
    "    while not dataQueue.empty():\n",
    "        pass\n",
    "\n",
    "    print(\"dataQueue为空\")\n",
    "\n",
    "    global PARSE_EXIT\n",
    "    PARSE_EXIT=True\n",
    "\n",
    "    for thread in threadParses:\n",
    "        thread.join()\n",
    "\n",
    "    with lock:\n",
    "        # 关闭文件,在关闭之前,内容都在内存里\n",
    "        localFile.close()\n",
    "\n",
    "\n",
    "if __name__==\"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.协程实现"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在上面实现的多线程爬虫中,分别开启了3个采集线程爬取网页和3个解析线程来解析网页,提供了程序执行的效率.但是,线程是交由CPU调度的,每个时间片段中只能有一个线程执行.而协程是在一个线程内部执行,一旦遇到了网络I/O阻塞,它就会立刻切换到另一个协程中执行,通过不断的轮询,降低了爬取网页的时间.对于爬虫而言,协程和多线程在效率上没有很大的不同"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用协程来实现爬虫,具体步骤如下：\n",
    "1. 定义一个负责爬虫的类,所有的爬虫工作完全交由该类负责\n",
    "2. 使用一个队列data_queue保存所有的数据\n",
    "3. 创建多个协程任务,每个协程都会使用页码构建完整的网址,访问网址爬取和提取有用的数据,并保存到数据队列中,直到所有网页中的数据提取出来\n",
    "4. 将data_queue队列中的数据全部提取出来,保存到本地文件duanzi.txt中"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/usr/bin/env python3\n",
    "# -*- coding:utf-8 -*-\n",
    "# Author LQ6H\n",
    "\n",
    "\n",
    "import requests\n",
    "from queue import Queue\n",
    "import time\n",
    "from lxml import etree\n",
    "import gevent\n",
    "\n",
    "class Spider(object):\n",
    "    def __init__(self):\n",
    "        self.headers={\n",
    "            \"User-Agent\":\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.108 Safari/537.36\"\n",
    "        }\n",
    "\n",
    "        self.base_url=\"https://www.qiushibaike.com/8hr/page/\"\n",
    "        # 创建保存数据的队列\n",
    "        self.data_queue=Queue()\n",
    "        # 统计数量\n",
    "        self.count=0\n",
    "\n",
    "    def send_request(self,url):\n",
    "        print(\"[INFO]：正在爬取\"+url)\n",
    "        html=requests.get(url,headers=self.headers).content\n",
    "        # 每次请求间隔1s\n",
    "        time.sleep(1)\n",
    "        self.parse_page(html)\n",
    "\n",
    "    def parse_page(self,html):\n",
    "        html_ogj=etree.HTML(html)\n",
    "        node_list=html_ogj.xpath('//li[contains(@id,\"qiushi_tag\")]')\n",
    "\n",
    "        for node in node_list:\n",
    "            try:\n",
    "\n",
    "                # 获取用户名\n",
    "                username = node.xpath('.//span[@class=\"recmd-name\"]/text()')\n",
    "\n",
    "                # 图片链接\n",
    "                image = node.xpath('.//img/@src')[0]\n",
    "\n",
    "                # 段子内容\n",
    "                content = node.xpath('.//a[@class=\"recmd-content\"]')[0].text\n",
    "\n",
    "                # 点赞\n",
    "                like = node.xpath('.//div[@class=\"recmd-num\"]/span')[0].text\n",
    "\n",
    "                # 评论\n",
    "                try:\n",
    "                    comments = node.xpath('.//div[@class=\"recmd-num\"]/span')[3].text\n",
    "                except IndexError:\n",
    "                    comments = 0\n",
    "\n",
    "                items = {\n",
    "                    \"username\": username,\n",
    "                    \"image\": image,\n",
    "                    \"content\": content,\n",
    "                    \"like\": like,\n",
    "                    \"comments\": comments\n",
    "                }\n",
    "\n",
    "                self.count+=1\n",
    "                self.data_queue.put(items)\n",
    "            except:\n",
    "                pass\n",
    "\n",
    "    def start_work(self):\n",
    "        job_list=[]\n",
    "        for page in range(1,11):\n",
    "            # 构建一个协程任务对象\n",
    "            url=self.base_url+str(page)+\"/\"\n",
    "            job=gevent.spawn(self.send_request,url)\n",
    "\n",
    "            # 保存所有的协程任务\n",
    "            job_list.append(job)\n",
    "\n",
    "        # joinall()接收一个列表,将列表中的所有协程任务添加到任务队列里执行\n",
    "        gevent.joinall(job_list)\n",
    "\n",
    "        local_file=open(\"duanzi.json\",\"wb+\")\n",
    "\n",
    "        while not self.data_queue.empty():\n",
    "            content=self.data_queue.get()\n",
    "            result=str(content).encode(\"utf-8\")\n",
    "            local_file.write(result+b\"\\n\")\n",
    "\n",
    "        local_file.close()\n",
    "        print(self.count)\n",
    "\n",
    "if __name__==\"__main__\":\n",
    "    spider=Spider()\n",
    "    spider.start_work()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.性能分析"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用单线程,多线程和协程实现数据的爬取后,通过计算这3种方式下的耗时情况,比较三种爬虫的效率"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先导入time模块,然后计算main()函数执行之后与之前的时间差,或者计算调用start_work()方法之前与调用之后的时间差"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "计算main()函数执行前后时间差："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__==\"__main__\":\n",
    "    startTime=time.time()\n",
    "    main()\n",
    "    print(time.time()-startTime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "计算start_work()方法调用前后时间差："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__==\"__main__\":\n",
    "    spider=Spider()\n",
    "    start=time.time()\n",
    "    spider.start_work()\n",
    "    print(\"[INFO]：Using time%f secend\"%(time.time()-start))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
